home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / SciAn / src / ScianNetObjects.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  33KB  |  1,513 lines
  1. /* ScianNetObjects.c
  2.  * John R. Murray
  3.  * June 1992
  4.  * Stuff for transmitting and receiving objects over sockets.
  5.  */
  6.  
  7. #include "Scian.h"
  8. #include "ScianIDs.h"
  9. #include "ScianTypes.h"
  10. #include "ScianNetObjects.h"
  11. #include "ScianSockets.h"
  12. #include "ScianLists.h"
  13. #include "ScianErrors.h"
  14. #include "ScianWindows.h"
  15. #include "ScianObjWindows.h"
  16. #include "ScianDatasets.h"
  17. #include "ScianNames.h"
  18. /* the following .h files are ONLY included for extern classes */
  19. #include "ScianArrays.h"
  20. #include "ScianTimers.h"
  21. #include "ScianVisObjects.h"
  22. /* this one's here for NewAtomicPalette function definition */
  23. #include "ScianColors.h"
  24.  
  25. #ifndef DEBUGSOCKETS
  26. #define DEBUGSOCKETS
  27. #endif
  28.  
  29. /* if the main body of the object is smaller than this, an obj without the
  30.  * extra bytes gets sent */
  31. #define NO_SIZE_THRESHOLD 1024
  32.  
  33. static ObjPtr allPublished;
  34. #ifdef SAVEDELETED
  35. static ObjPtr allDeletedPublished;
  36. #endif
  37.  
  38. #ifdef SOCKETS
  39.  
  40. unsigned int lastNetworkID = 0;
  41.  
  42. unsigned long GetNetworkID()
  43. {
  44.     return ++lastNetworkID;
  45. }
  46.  
  47.  
  48. void AssembleNetObjectVars (vnode, start)
  49. VarsPtr vnode;
  50. char **start;
  51. {
  52.     if (!vnode)
  53.     return;
  54.  
  55.     if (!ThisWouldBeAReallyBadThing(vnode -> name))
  56.     {
  57.  
  58. if (!vnode -> value)
  59. {
  60.     fprintf(stderr, "WARNING!! Sending var %ld with value NULLOBJ\n", vnode -> name);
  61. }
  62.  
  63. #ifdef DEBUGSOCKETS
  64. #ifdef DEBUG
  65.     fprintf(stderr, "var %d\n", vnode -> name);
  66. #endif
  67.     sprintf(*start, "%d ", vnode -> name);
  68.     *start += strlen(*start);
  69. #else
  70.     *((NameTyp *) *start) = HTON_NAMETYP(vnode -> name);
  71.     *start += sizeof(NameTyp);
  72. #endif
  73.     }
  74.     AssembleNetObjectVars (vnode -> left, start);
  75.     AssembleNetObjectVars (vnode -> right, start);
  76. }
  77.  
  78. char *GetNetTypeStr(obj, connection)
  79. ObjPtr obj, connection;
  80. {
  81.     ObjPtr class;
  82.  
  83.     class = ClassOf(obj);
  84.  
  85.     if (class == iconDataset)
  86.     return NET_ICONDATASET;
  87.     else if (class == icon1DVector)
  88.     return NET_ICON1DVECTOR;
  89.     else if (class == icon2DVector)
  90.         return NET_ICON2DVECTOR;
  91.     else if (class == icon3DVector)
  92.         return NET_ICON3DVECTOR;
  93.     else if (class == icon4DVector)
  94.         return NET_ICON4DVECTOR;
  95.     else if (class == icon1DScalar)
  96.         return NET_ICON1DSCALAR;
  97.     else if (class == icon2DScalar)
  98.         return NET_ICON2DSCALAR;
  99.     else if (class == icon3DScalar)
  100.         return NET_ICON3DSCALAR;
  101.     else if (class == icon4DScalar)
  102.         return NET_ICON4DSCALAR;
  103.     else if (class == data3DScalar)
  104.         return NET_DATA3DSCALAR;
  105.     else if (class == data2DScalar)
  106.         return NET_DATA2DSCALAR;
  107.     else if (class == data1DVector)
  108.         return NET_DATA1DVECTOR;
  109.     else if (class == data3DUnstructSurface)
  110.         return NET_DATA3DUNSTRUCT;
  111.     else if (class == datasetClass)
  112.     return NET_DATASET;
  113.     else if (class == dataFormClass)
  114.     return NET_DATAFORM;
  115.     else if (class == stringClass)
  116.     return NET_STRING;
  117.     else if (class == objClass && IsInt(obj))
  118.     return NET_INTEGER;
  119.     else if (class == objClass && IsReal(obj))
  120.     return NET_REAL;
  121.     else if (class == objClass)
  122.     return NET_PLAINOBJECT;
  123.     else if (class == arrayClass)
  124. #if MACHINE == IRIS4D
  125. #ifdef FASTSOCKETS
  126.     return NET_REALARRAYRAW;
  127. #else
  128.     if (GetPredicate(connection, FASTSOCKET))
  129.     {
  130.         return NET_REALARRAYRAW;
  131.     }
  132.     else
  133.     {
  134.         return NET_REALARRAYASCII;
  135.     }
  136. #endif
  137. #else
  138.     return NET_REALARRAYASCII;
  139. #endif
  140.     else if (class == objectArrayClass)
  141.     return NET_OBJECTARRAY;
  142.     else if (class == timedObjClass)
  143.     return NET_TIMEDOBJECT;
  144.     else if (class == paletteClass)
  145.     return NET_PALETTE;
  146.     else if (class == visIcon)
  147. {
  148. fprintf(stderr, "sending visIcon\n");
  149.     return NET_VISICON;
  150. }
  151.     else
  152.     {
  153.     fprintf(stderr, "trying to transmit obj of unrecognized class\n");
  154.     fprintf(stderr, "class = 0x%x\n", class);
  155.     return NET_UNIMPLEMENTED;
  156.     }
  157. }
  158.  
  159. void TransmitObject(obj, connection, flag)
  160. ObjPtr obj, connection;
  161. Bool flag;
  162. /* transmit obj across connection. if flag, send OBJ! message header, or not */
  163. {
  164.     char buf[1024];
  165.     char *bufp;
  166.     int sock;
  167.     int networkID;
  168.     ObjPtr networkIDPtr;
  169.     NetFlagsTyp netFlags;
  170.     FuncTyp method;
  171.     FlagsTyp flagstmp;
  172.  
  173.     networkID = PublishObject(obj);
  174.  
  175.     sock = ((ConnectionPtr) connection) -> sock;
  176.  
  177.     if (sock < 0)
  178.     return;
  179.  
  180.     bufp = buf;
  181.  
  182.     if (flag)
  183.     {
  184.     sprintf(bufp, "%s ", NO_MESG_OBJECT);
  185.     bufp += strlen(bufp);
  186.     }
  187.  
  188.     /* sending network type identifier */
  189.     sprintf(bufp, "%s ", GetNetTypeStr(obj, connection));
  190.     bufp += strlen(bufp);
  191.  
  192.     /* sending network ID number */
  193. #ifdef DEBUG
  194. fprintf(stderr, "xmitting netid %ld\n", networkID);
  195. #endif
  196.     sprintf(bufp, "%ld ", networkID);
  197.     bufp += strlen(bufp);
  198.  
  199.     /* send object flags */
  200.     flagstmp = obj -> flags;
  201.     flagstmp = flagstmp & ~ISPUBLISHED;
  202.     if (GetVar(obj, ADVERTISED))
  203.     {
  204.     flagstmp = flagstmp | ISREMOTEADVERTISED;
  205.     }
  206.     sprintf(bufp, "%ld ", flagstmp);
  207.     bufp += strlen(bufp);
  208.  
  209.     /* send network flags */
  210.     netFlags = ( !obj -> class ? NO_NULL_CLASS : 0 )
  211.            | ( !obj -> vars ? NO_NULL_VARS : 0 )
  212.            | ( !obj -> methods ? NO_NULL_METHODS : 0 )
  213.            | ( !obj -> depends ? NO_NULL_DEPENDS : 0 );
  214.  
  215.     sprintf(bufp, "%ld ", netFlags);
  216.     bufp += strlen(bufp);
  217.  
  218.     /* send variables */
  219.     AssembleNetObjectVars(obj -> vars, &bufp);
  220.     sprintf(bufp, "%d ", NO_LAST_VAR);
  221.     bufp += strlen(bufp);
  222.  
  223. #ifdef DEBUG
  224.     fprintf(stderr, "%s", buf);
  225. #endif
  226.  
  227.     if (bufp - buf > 1024)
  228.     {
  229.     fprintf(stderr, "TransmitObject: overran buffer!\n");
  230.     }
  231.  
  232.     writen(sock, buf, bufp - buf);
  233.  
  234.     method = GetMethod(obj, TRANSMITEXTRA);
  235.     if (method)
  236.     {
  237. /*BIG HAK!*/
  238. #if MACHINE == RS6000
  239. #else
  240.     if (GetPredicate(connection, FASTSOCKET)
  241.         && (method == TransmitExtraStuffRealArrayAscii))
  242.     {
  243. #ifdef DEBUG
  244.         fprintf(stderr, "fast\n");
  245. #endif
  246.         TransmitExtraStuffRealArrayRaw(obj, connection);
  247.     }
  248.     else
  249. #endif
  250.     {
  251.         (* method) (obj, connection);
  252.     }
  253.     }
  254.  
  255.     /* send line terminator */
  256.     buf[0] = '\n';
  257.     buf[1] = '\0';
  258. #ifdef DEBUG
  259.     fprintf(stderr, "%s", buf);
  260. #endif
  261.  
  262.     writen(sock, buf, strlen(buf));
  263.  
  264. }
  265.  
  266. #define ROS_BEGIN        0    /* startup state */
  267. #define ROS_READ_NET_TYPE    1    /* reading the type of this object */
  268. #define ROS_READ_FLAGS        2    /* reading the object flags */
  269. #define ROS_READ_NETFLAGS    3    /* reading the net flags */
  270. #define ROS_READ_VARS        4    /* reading the vars */
  271. #define ROS_ERROR        5    /* blammo */
  272. #define ROS_DONE        6    /* I'm done */
  273. #define ROS_READ_NETWORKID    7    /* reading the network identifier */
  274.  
  275. ObjPtr ReceiveObject(connection, remoteChCount)
  276. ObjPtr connection;
  277. unsigned long remoteChCount;
  278. {
  279.     int state;
  280.     ObjPtr retVal;
  281.     char objType, inChar;
  282.     int someDigits;
  283.     unsigned long ltmp;
  284.     int networkID;
  285.     int sock;
  286.     char s[100];
  287.     int netID = 0;
  288.     int varNum = 0;
  289.     int debug = 0;    /* setting this to 1 will fprintf the internal states */
  290.     ObjPtr process;
  291.  
  292.     ltmp = 0; /* we'll have to do something else with ltmp when we make this reentrant */
  293.     state = ROS_BEGIN;
  294.     sock = ((ConnectionPtr) connection) -> sock;
  295.  
  296.     if (sock < 0)
  297.     {
  298.     ReportError("ReceiveObject", "Bad socket");
  299.     return ObjFalse;
  300.     }
  301.  
  302.     process = GetObjectVar("ReceiveObject", connection, OWNERPROCESS);
  303.     if (!process)
  304.     {
  305.     ReportError("ReceiveObject", "connection has no OWNERPROCESS");
  306.     return ObjFalse;
  307.     }
  308.  
  309.     while (state != ROS_DONE)
  310.     {
  311.     switch(state)
  312.     {
  313.         case ROS_BEGIN:
  314. if (debug) fprintf(stderr, "state = BEGIN\n");
  315.         state = ROS_READ_NET_TYPE;
  316.         s[0] = '\0';
  317.         break;
  318.         case ROS_READ_NET_TYPE:    /* initial entry assumes s == "" */
  319. if (debug) fprintf(stderr, "state = READ_NET_TYPE\n");
  320.         if (1 == read(sock, &inChar, 1))
  321.         {
  322. #if 0
  323.             if (inChar == '\n' || inChar == '\0')
  324.             {
  325.             ((ConnectionPtr) connection) -> gotCmdEnd = true;
  326.             ltmp = 0;
  327.             state = ROS_ERROR;
  328.             }
  329.             else
  330. #endif
  331.             if (!isspace(inChar))
  332.             {
  333.             if (strlen(s) <= 4)
  334.             {
  335.                 strncat(s, &inChar, 1);    /* append one char */
  336.             }
  337.             else
  338.             {
  339.                 state = ROS_ERROR; /* net type too long */
  340.             }
  341.             /* skip initial blanks */
  342.             }
  343.             else if (s[0] == '\0')    /* no characters yet */
  344.             {
  345.             /* skip initial blanks */
  346.             }
  347.             else if (strlen(s) != 4)
  348.             {
  349.             state = ROS_ERROR;
  350.             }
  351.             else    /* it's a space, and we've got 4 characters */
  352.             {
  353.             long cmdNum;
  354.  
  355.             cmdNum = CMD(s);
  356.             if (cmdNum == CMD(NET_PLAINOBJECT))
  357.             {
  358.                 retVal = NewObject(0, 0);
  359.             }
  360.             else if (cmdNum == CMD(NET_INTEGER))
  361.             {
  362.                 retVal = NewInt(0);
  363.             }
  364.             else if (cmdNum == CMD(NET_REAL))
  365.             {
  366.                 retVal = NewReal(0);
  367.             }
  368.             else if (cmdNum == CMD(NET_STRING))
  369.             {
  370.                 retVal = NewString("");
  371.             }
  372. #if MACHINE == IRIS4D
  373.             else if (cmdNum == CMD(NET_REALARRAYRAW))
  374.             {
  375.                 retVal = NewRealArray(1, 1L);
  376.                 SetMethod(retVal, TRANSMITEXTRA, TransmitExtraStuffRealArrayRaw);
  377.                 SetMethod(retVal, RECEIVEEXTRA, ReceiveExtraStuffRealArrayRaw);
  378.             }
  379. #endif
  380.             else if (cmdNum == CMD(NET_REALARRAYASCII))
  381.             {
  382.                 retVal = NewRealArray(1, 1L);
  383.             }
  384.             else if (cmdNum == CMD(NET_OBJECTARRAY))
  385.             {
  386.                 long dummy;
  387.                 dummy = 1L;
  388.                 retVal = NewArray(AT_OBJECT, 1, &dummy);
  389.             }
  390.             else if (cmdNum == CMD(NET_ICONDATASET))
  391.             {
  392.                 retVal = NewObject(iconDataset, 0);
  393.             }
  394.             else if (cmdNum == CMD(NET_ICON1DVECTOR))
  395.             {
  396.                 retVal = NewObject(icon1DVector, 0);
  397.             }
  398.             else if (cmdNum == CMD(NET_ICON2DVECTOR))
  399.             {
  400.                 retVal = NewObject(icon2DVector, 0);
  401.             }
  402.             else if (cmdNum == CMD(NET_ICON3DVECTOR))
  403.             {
  404.                 retVal = NewObject(icon3DVector, 0);
  405.             }
  406.             else if (cmdNum == CMD(NET_ICON4DVECTOR))
  407.             {
  408.                 retVal = NewObject(icon4DVector, 0);
  409.             }
  410.             else if (cmdNum == CMD(NET_ICON1DSCALAR))
  411.             {
  412.                 retVal = NewObject(icon1DScalar, 0);
  413.             }
  414.             else if (cmdNum == CMD(NET_ICON2DSCALAR))
  415.             {
  416.                 retVal = NewObject(icon2DScalar, 0);
  417.             }
  418.             else if (cmdNum == CMD(NET_ICON3DSCALAR))
  419.             {
  420.                 retVal = NewObject(icon3DScalar, 0);
  421.             }
  422.             else if (cmdNum == CMD(NET_ICON4DSCALAR))
  423.             {
  424.                 retVal = NewObject(icon4DScalar, 0);
  425.             }
  426.             else if (cmdNum == CMD(NET_DATA1DVECTOR))
  427.             {
  428.                 retVal = NewObject(data1DVector, 0);
  429.             }
  430.             else if (cmdNum == CMD(NET_DATA2DSCALAR))
  431.             {
  432.                 retVal = NewObject(data2DScalar, 0);
  433.             }
  434.             else if (cmdNum == CMD(NET_DATA3DSCALAR))
  435.             {
  436.                 retVal = NewObject(data3DScalar, 0);
  437.             }
  438.             else if (cmdNum == CMD(NET_DATA3DUNSTRUCT))
  439.             {
  440.                 retVal = NewObject(data3DUnstructSurface, 0);
  441.             }
  442.             else if (cmdNum == CMD(NET_DATASET))
  443.             {
  444.                 retVal = NewObject(datasetClass, 0);
  445.             }
  446.             else if (cmdNum == CMD(NET_DATAFORM))
  447.             {
  448.                 retVal = NewObject(dataFormClass, 0);
  449.             }
  450.             else if (cmdNum == CMD(NET_TIMEDOBJECT))
  451.             {
  452.                 retVal = NewObject(timedObjClass, 0);
  453.             }
  454.             else if (cmdNum == CMD(NET_PALETTE))
  455.             {
  456.                 retVal = NewAtomicPalette();
  457.             }
  458.             else if (cmdNum == CMD(NET_VISICON))
  459.             {
  460.                 retVal = NewObject(visIcon, 0);
  461.             }
  462.             else if (cmdNum == CMD(NET_UNIMPLEMENTED))
  463.             {
  464.                 fprintf(stderr, "remote process transmitted unimplemented net type\ntreating it as plain object\n");
  465.                 retVal = NewObject(0, 0);
  466.             }
  467.             else
  468.             {
  469.                 fprintf(stderr, "unrecognized net type %4s\n", s);
  470.                 return ObjFalse;
  471.             }
  472.             ltmp = 0;
  473.             someDigits = false;
  474.             state = ROS_READ_NETWORKID;
  475.             }
  476.         }
  477.         break;
  478.         case ROS_READ_NETWORKID:    /* initial entry assumes ltmp == 0 && someDigits == false */
  479. if (debug) fprintf(stderr, "state = READ_NETWORKID\n");
  480. #ifdef DEBUGSOCKETS
  481.         if (1 == read(sock, &inChar, 1))
  482.         {
  483.             if (isspace(inChar) && (inChar != '\n') && !someDigits)
  484.             {
  485.             /* skipping blanks */
  486.             }
  487.             else if (inChar >= '0' && inChar <= '9')
  488.             {
  489.             someDigits = true;
  490.             ltmp *= 10;
  491.             ltmp += inChar - '0';
  492.             }
  493.             else if (inChar == '\0' || inChar == '\n')
  494.             {
  495.             ((ConnectionPtr) connection) -> gotCmdEnd = true;
  496.             state = ROS_ERROR;
  497.             }
  498.             else if (!someDigits)
  499.             {
  500.             state = ROS_ERROR;
  501.             }
  502.             else
  503.             {
  504. if (debug) fprintf(stderr, "setting NETWORKID to %d\n", ltmp);
  505.             networkID = ltmp;
  506.             someDigits = false;
  507.             ltmp = 0;
  508.             state = ROS_READ_FLAGS;
  509.             }
  510.         }
  511. #else
  512.         Yabbadabba!
  513. #endif
  514.         break;
  515.         case ROS_READ_FLAGS:    /* 1st entry assumes ltmp == 0  & someDigits == false */
  516. if (debug) fprintf(stderr, "state = READ_FLAGS\n");
  517. #ifdef DEBUGSOCKETS
  518.         if (1 == read(sock, &inChar, 1))
  519.         {
  520.             if (isspace(inChar) && (inChar != '\n') && !someDigits)
  521.             {
  522.             /* skipping blanks */
  523.             }
  524.             else if (inChar >= '0' && inChar <= '9')
  525.             {
  526.             someDigits = true;
  527.             ltmp *= 10;
  528.             ltmp += inChar - '0';
  529.             }
  530.             else if (inChar == '\0' || inChar == '\n')
  531.             {
  532.             ((ConnectionPtr) connection) -> gotCmdEnd = true;
  533.             state = ROS_ERROR;
  534.             }
  535.             else
  536.             {
  537.             retVal -> flags = ltmp;
  538.             ltmp = 0;
  539.             someDigits = false;
  540.             state = ROS_READ_NETFLAGS;
  541.             }
  542.         }
  543. #else
  544.         Yabbadabba!
  545. #endif
  546.         break;
  547.         case ROS_READ_NETFLAGS:    /* initial entry assumes ltmp == 0 && someDigits == false */
  548. if (debug) fprintf(stderr, "state = READ_NETFLAGS\n");
  549. #ifdef DEBUGSOCKETS
  550.         if (1 == read(sock, &inChar,1))
  551.         {
  552.             if (isspace(inChar) && (inChar != '\n') && !someDigits)
  553.             {
  554.             /* skipping blanks */
  555.             }
  556.             else if (inChar >= '0' && inChar <= '9')
  557.             {
  558.             someDigits = true;
  559.             ltmp *= 10;
  560.             ltmp += inChar - '0';
  561.             }
  562.             else if (inChar == '\n' || inChar == '\0')
  563.             {
  564.             ((ConnectionPtr) connection) -> gotCmdEnd = true;
  565.             state = ROS_ERROR;
  566.             }
  567.             else
  568.             {
  569.             /* done reading netflags */
  570. if (debug) fprintf(stderr, "object's netflags == %lx\n", ltmp);
  571.             if (ltmp & NO_NULL_CLASS)
  572.             {
  573.                 /* ignored for now */
  574.             }
  575.  
  576.             if (ltmp & NO_NULL_VARS)
  577.             {
  578.                 /* ignored for now */
  579.             }
  580.  
  581.             if (ltmp & NO_NULL_METHODS)
  582.             {
  583.                 /* ignored */
  584.             }
  585.  
  586.             if (ltmp & NO_NULL_DEPENDS)
  587.             {
  588.                 /* ignored */
  589.             }
  590.  
  591.             ltmp = 0;
  592.             someDigits = false;
  593.             state = ROS_READ_VARS;
  594.             }
  595.         }
  596. #else
  597.         Yabbadabba!
  598. #endif
  599.         break;
  600.         case ROS_READ_VARS:    /* initial entry assumes ltmp == 0 and someDigits == false */
  601. /* if (debug) fprintf(stderr, "state = READ_VARS\n"); */
  602. if (debug) fprintf(stderr, "state = READ_VARS... ");
  603.         if (1 == read(sock, &inChar, 1))
  604.         {
  605. if (debug) fprintf(stderr, "char '%c'\n", inChar);
  606.             if (isspace(inChar) && (inChar != '\n') && !someDigits)
  607.             {
  608.             /* skipping blanks */
  609.             }
  610.             else if (inChar >= '0' && inChar <= '9')
  611.             {
  612.             someDigits = true;
  613.             ltmp *= 10;
  614.             ltmp += inChar - '0';
  615.             }
  616.             else if (inChar == '\n' || inChar == '\0')
  617.             {
  618.             ((ConnectionPtr) connection) -> gotCmdEnd = true;
  619.             state = ROS_ERROR;
  620.             }
  621.             else if (ltmp != NO_LAST_VAR)
  622.             {
  623.             VarsPtr vPtr;
  624.             SetVar (retVal, ltmp, NULLOBJ);
  625.             vPtr = GetVarNode(retVal, ltmp);
  626.             vPtr -> process = process;
  627.             vPtr -> remoteNetID = NETSTUBFLAG;
  628.             vPtr -> remoteChCount = anotherDamnReferenceCount;
  629.             ltmp = 0;
  630.             someDigits = false;
  631.             }
  632.             else
  633.             {
  634.             /* that may have been the end var marker */
  635.             if (someDigits)
  636.             {
  637.                 if (SanityCheckObject(retVal))
  638.                 {
  639.                 FuncTyp method;
  640.  
  641.                 method = GetMethod(retVal, RECEIVEEXTRA);
  642.                 if (method)
  643.                 {
  644.                     (* method) (retVal, connection);
  645.                 }
  646.                 state = ROS_DONE;
  647.                 }
  648.                 else
  649.                 {
  650.                 ReportError("ReceiveObject", "An incoming network object failed Sanity Check");
  651.                 state = ROS_ERROR;
  652.                 }
  653.             }
  654.             else
  655.             {
  656.                 state = ROS_ERROR;
  657.             }
  658.             }
  659.         }
  660.         break;
  661.         case ROS_ERROR:    /* no assumptions on inital entry */
  662. if (debug) fprintf(stderr, "state = ERROR\n");
  663.         ReportError("ReceiveObject", "Error in receiving network object");
  664.         return ObjFalse;
  665.         break;
  666.         default:
  667.         fprintf(stderr, "funny state in ReceiveObject!\n");
  668.         break;
  669.     }
  670.     }
  671.  
  672.     SetVar(retVal, NETWORKID, NewInt(networkID));
  673.     if (remoteChCount) SetVar(retVal, REMOTECHCOUNT, NewInt(remoteChCount));
  674.     SetVar(retVal, OWNERCONNECTION, connection);
  675.     retVal -> flags = retVal -> flags | ISREMOTE;
  676. if (debug) PrintObject(retVal);
  677. if (debug) PrintVarTree(retVal);
  678.     NetworkIDIsWaiting(process, networkID, false);
  679.     return retVal;
  680. }
  681.  
  682. real ReceiveRealAscii(connection)
  683. ObjPtr connection;
  684. {
  685.     real retVal;
  686.     int sock;
  687.     char inChar, s[100];
  688.     int si;
  689.     double time;
  690.     Bool someDigits;
  691.  
  692.     si = 0;
  693.     s[si] = '\0';
  694.     someDigits = false;
  695.     time = Clock();
  696.  
  697.     sock = ((ConnectionPtr) connection) -> sock;
  698.  
  699.     while (Clock() < time + JOHNSTIMEOUT && !((ConnectionPtr) connection) -> gotCmdEnd)
  700.     {
  701.     if (1 == read(sock, &inChar, 1))
  702.     {
  703.         if (isspace(inChar) && (inChar != '\n') && !someDigits)
  704.         {
  705.         /* skipping blanks */
  706.         }
  707.         else if (si >= 100 || (inChar >= '0' && inChar <= '9')
  708.             || inChar == '-' || inChar == 'e' || inChar == 'E'
  709.             || inChar == '+' || inChar == '-' || inChar == '.')
  710.         {
  711.         someDigits = true;
  712.         s[si++] = inChar;
  713.         s[si] = '\0';
  714.         }
  715.         else
  716.         {
  717.         int len;
  718.  
  719.         if (inChar == '\0' || inChar == '\n')
  720.         {
  721.             ((ConnectionPtr) connection) -> gotCmdEnd = true;
  722.         }
  723.  
  724.         /* make sure we read etwas that takes up the whole string */
  725.         if (someDigits && (1 != sscanf(s, "%100g%n", &retVal, &len)
  726.                    || len < strlen(s)))
  727.         {
  728. fprintf(stderr, "bad sscanf return. s = %s, len = %d, strlen(s) = %d.\n", s, len, strlen(s));
  729.             return -1;
  730.         }
  731.         return retVal;
  732.         }
  733.     }
  734.     }
  735.     /* only got here if we timed out */
  736. fprintf(stderr, "hack timeout in ReceiveRealAscii\n");
  737.     return -1;
  738. }
  739.  
  740. ObjPtr TransmitExtraStuffRealArrayRaw(obj, connection)
  741. ObjPtr obj, connection;
  742. {
  743.     int sock;
  744.     int rank;
  745.     long *dimp;
  746.     int i;
  747.     long nels;
  748.     real *elsPtr;
  749.  
  750.     sock = ((ConnectionPtr) connection) -> sock;
  751.  
  752.     rank = RANK(obj);
  753. #ifdef DEBUG
  754.     fprintf(stderr, "sending rank = %d.. ", rank);
  755. #endif
  756.     writen(sock, (char *) &rank, sizeof(rank));
  757.  
  758. #ifdef DEBUG
  759.     fprintf(stderr, "sending dims");
  760. #endif
  761.     dimp = DIMS(obj);
  762.     nels = 1;
  763.     for (i = 0; i < rank; ++i)
  764.     {
  765. #ifdef DEBUG
  766.     fprintf(stderr, " d%d=%ld", i, *dimp);
  767. #endif
  768.     writen(sock, (char *) dimp, sizeof(*dimp));
  769.     nels *= *dimp;
  770.     ++dimp;
  771.     }
  772. #ifdef DEBUG
  773.     fprintf(stderr, ". done with dims\n");
  774.     fprintf(stderr, "trying to write %ld * 4 bytes of data\n", nels);
  775. #endif
  776.     elsPtr = ELEMENTS(obj);
  777.     writen(sock, (char *) elsPtr, sizeof(*elsPtr) * nels);
  778. }
  779.  
  780. ObjPtr ReceiveExtraStuffRealArrayRaw(obj, connection)
  781. ObjPtr obj, connection;
  782. {
  783.     int sock, rank, i;
  784.     long *dimp, nels, oneDim;
  785.     real *elsPtr;
  786.  
  787.     sock = ((ConnectionPtr) connection) -> sock;
  788.  
  789.     readn(sock, (char *) &rank, sizeof(rank));
  790. /* fprintf(stderr, "rank = %ld\n",  */
  791. #ifdef DEBUG
  792.     fprintf(stderr, "got rank = %d\n", rank);
  793. #endif
  794.     RANK(obj) = rank;
  795.  
  796. #ifdef DEBUG
  797.     fprintf(stderr, "getting dims -");
  798. #endif
  799.     dimp = Alloc(rank * sizeof(long));
  800.     DIMS(obj) = dimp;
  801.     nels = 1;
  802.     for (i = 0; i < rank; ++i)
  803.     {
  804.     readn(sock, (char *) &oneDim, sizeof(long));
  805.     nels *= oneDim;
  806.     *dimp = oneDim;
  807.     ++dimp;
  808. #ifdef DEBUG
  809.     fprintf(stderr, " d%d=%ld", i, oneDim);
  810. #endif
  811.     }
  812. #ifdef DEBUG
  813.     fprintf(stderr, ". done with dims\n");
  814. #endif
  815.  
  816.     elsPtr = (void *) Alloc(nels * sizeof(real));
  817.     if (!elsPtr)
  818.     {
  819.     OMErr();
  820.     return ObjFalse;
  821.     }
  822.     ELEMENTS(obj) = elsPtr;
  823.  
  824. #ifdef DEBUG
  825.     fprintf(stderr, "trying to read 4 * %d bytes\n", nels);
  826. #endif
  827.     readn(sock, (char *) elsPtr, sizeof(real) * nels);
  828. #ifdef DEBUG
  829.     fprintf(stderr, "...wow! did it work??\n");
  830. #endif
  831. }
  832.  
  833. ObjPtr TransmitExtraStuffRealArrayAscii(obj, connection)
  834. ObjPtr obj, connection;
  835. {
  836.     int sock;
  837.     int rank;
  838.     long *dimp;
  839.     long i;
  840.     long nels;
  841.     real *elsPtr;
  842.  
  843.     sock = ((ConnectionPtr) connection) -> sock;
  844.  
  845.     rank = RANK(obj);
  846. #ifdef DEBUG
  847.     fprintf(stderr, "sending rank = %d.. ", rank);
  848. #endif
  849.     sprintf(tempStr, "%d ", rank);
  850.     writen(sock, tempStr, strlen(tempStr));
  851.  
  852. #ifdef DEBUG
  853.     fprintf(stderr, "sending dims");
  854. #endif
  855.     dimp = DIMS(obj);
  856.     nels = 1;
  857.     for (i = 0; i < rank; ++i)
  858.     {
  859. #ifdef DEBUG
  860.     fprintf(stderr, " d%d=%ld", i, *dimp);
  861. #endif
  862.     sprintf(tempStr, "%ld ", *dimp);
  863.     writen(sock, tempStr, strlen(tempStr));
  864.     nels *= *dimp;
  865.     ++dimp;
  866.     }
  867. #ifdef DEBUG
  868.     fprintf(stderr, ". done with dims\n");
  869.     fprintf(stderr, "trying to write %ld ascii numbers\n", nels);
  870. #endif
  871.     elsPtr = ELEMENTS(obj);
  872.     for (i = 0; i < nels; ++i)
  873.     {
  874.     sprintf(tempStr, "%g ", elsPtr[i]);
  875.     writen(sock, tempStr, strlen(tempStr));
  876.     }
  877. }
  878.  
  879. ObjPtr ReceiveExtraStuffRealArrayAscii(obj, connection)
  880. ObjPtr obj, connection;
  881. {
  882.     int sock, rank, i;
  883.     long *dimp, nels, oneDim;
  884.     real *elsPtr;
  885.  
  886.     sock = ((ConnectionPtr) connection) -> sock;
  887.  
  888.     rank = ReceiveRealAscii(connection);
  889. #ifdef DEBUG
  890.     fprintf(stderr, "got rank = %d\n", rank);
  891. #endif
  892.     RANK(obj) = rank;
  893.  
  894. #ifdef DEBUG
  895.     fprintf(stderr, "getting dims -");
  896. #endif
  897.     dimp = Alloc(rank * sizeof(long));
  898.     DIMS(obj) = dimp;
  899.     nels = 1;
  900.     for (i = 0; i < rank; ++i)
  901.     {
  902.     oneDim = ReceiveRealAscii(connection);
  903.     nels *= oneDim;
  904.     *dimp = oneDim;
  905.     ++dimp;
  906. #ifdef DEBUG
  907.     fprintf(stderr, " d%d=%ld", i, oneDim);
  908. #endif
  909.     }
  910. #ifdef DEBUG
  911.     fprintf(stderr, ". done with dims\n");
  912. #endif
  913.  
  914.     elsPtr = (void *) Alloc(nels * sizeof(real));
  915.     if (!elsPtr)
  916.     {
  917.     OMErr();
  918.     return ObjFalse;
  919.     }
  920.  
  921.     ELEMENTS(obj) = elsPtr;
  922. #ifdef DEBUG
  923.     fprintf(stderr, "trying to read %ld elements..", nels);
  924. #endif
  925.     for (i = 0; i < nels; ++i)
  926.     {
  927.     elsPtr[i] = ReceiveRealAscii(connection);
  928.     }
  929. #ifdef DEBUG
  930.     fprintf(stderr, "wow! did it work??\n");
  931. #endif
  932.     return ObjTrue;
  933. }
  934.  
  935. ObjPtr TransmitExtraStuffObjectArraySpecial(obj, connection)
  936. ObjPtr obj, connection;
  937. {
  938.     int sock;
  939.     int rank;
  940.     long *dimp;
  941.     long i;
  942.     long nels;
  943.     ObjPtr *elsPtr;
  944.     double startTime;
  945.  
  946.     startTime = Clock();
  947.  
  948.     sock = ((ConnectionPtr) connection) -> sock;
  949.  
  950.     rank = RANK(obj);
  951. #ifdef DEBUG
  952.     fprintf(stderr, "sending rank = %d.. ", rank);
  953. #endif
  954.     sprintf(tempStr, "%d ", rank);
  955.     writen(sock, tempStr, strlen(tempStr));
  956.  
  957. #ifdef DEBUG
  958.     fprintf(stderr, "sending dims");
  959. #endif
  960.     dimp = DIMS(obj);
  961.     nels = 1;
  962.     for (i = 0; i < rank; ++i)
  963.     {
  964. #ifdef DEBUG
  965.     fprintf(stderr, " d%d=%ld", i, *dimp);
  966. #endif
  967.     sprintf(tempStr, "%ld ", *dimp);
  968.     writen(sock, tempStr, strlen(tempStr));
  969.     nels *= *dimp;
  970.     ++dimp;
  971.     }
  972. #ifdef DEBUG
  973.     fprintf(stderr, ". done with dims\n");
  974. #endif
  975.  
  976.     elsPtr = ELEMENTS(obj);
  977.     for (i = 0; i < nels; ++i)
  978.     {
  979.     TransmitObject(elsPtr[i], connection, false);
  980.     }
  981.     fprintf(stderr, "object array transmit time %10.4lf\n", Clock() - startTime);
  982. }
  983.  
  984. ObjPtr ReceiveExtraStuffObjectArraySpecial(obj, connection)
  985. ObjPtr obj, connection;
  986. {
  987.     int sock, rank, i;
  988.     long *dimp, nels, oneDim;
  989.     ObjPtr *elsPtr;
  990.     double startTime;
  991.  
  992.     startTime = Clock();
  993.  
  994.     sock = ((ConnectionPtr) connection) -> sock;
  995.  
  996.     rank = ReceiveRealAscii(connection);
  997. #ifdef DEBUG
  998.     fprintf(stderr, "got rank = %d\n", rank);
  999. #endif
  1000.     RANK(obj) = rank;
  1001.  
  1002. #ifdef DEBUG
  1003.     fprintf(stderr, "getting dims -");
  1004. #endif
  1005.     dimp = Alloc(rank * sizeof(long));
  1006.     DIMS(obj) = dimp;
  1007.     nels = 1;
  1008.     for (i = 0; i < rank; ++i)
  1009.     {
  1010.     oneDim = ReceiveRealAscii(connection);
  1011.     nels *= oneDim;
  1012.     *dimp = oneDim;
  1013.     ++dimp;
  1014. #ifdef DEBUG
  1015.     fprintf(stderr, " d%d=%ld", i, oneDim);
  1016. #endif
  1017.     }
  1018. #ifdef DEBUG
  1019.     fprintf(stderr, ". done with dims\n");
  1020. #endif
  1021.  
  1022.     elsPtr = (void *) Alloc(nels * sizeof(ObjPtr));
  1023.     if (!elsPtr)
  1024.     {
  1025.     OMErr();
  1026.     return ObjFalse;
  1027.     }
  1028.  
  1029.     ELEMENTS(obj) = elsPtr;
  1030.     for (i = 0; i < nels; ++i)
  1031.     {
  1032.     ((ConnectionPtr) connection) -> gotCmdEnd = false;
  1033.     elsPtr[i] = ReceiveObject(connection, 0);
  1034.     }
  1035. fprintf(stderr, "object array receive time %10.4lf\n", Clock() - startTime);
  1036.     return ObjTrue;
  1037. }
  1038.  
  1039. #if 1
  1040. ObjPtr TransmitExtraStuffObjectArray(obj, connection)
  1041. ObjPtr obj, connection;
  1042. {
  1043.     TransmitExtraStuffObjectArraySpecial(obj, connection);
  1044. }
  1045. #else
  1046. ObjPtr TransmitExtraStuffObjectArray(obj, connection)
  1047. ObjPtr obj, connection;
  1048. {
  1049.     int sock;
  1050.     int rank;
  1051.     long *dimp;
  1052.     long i;
  1053.     long nels;
  1054.     real *elsPtr;
  1055.  
  1056.     sock = ((ConnectionPtr) connection) -> sock;
  1057.  
  1058.     rank = RANK(obj);
  1059. #ifdef DEBUG
  1060.     fprintf(stderr, "sending rank = %d.. ", rank);
  1061. #endif
  1062.     sprintf(tempStr, "%d ", rank);
  1063.     writen(sock, tempStr, strlen(tempStr));
  1064.  
  1065. #ifdef DEBUG
  1066.     fprintf(stderr, "sending dims");
  1067. #endif
  1068.     dimp = DIMS(obj);
  1069.     nels = 1;
  1070.     for (i = 0; i < rank; ++i)
  1071.     {
  1072. #ifdef DEBUG
  1073.     fprintf(stderr, " d%d=%ld", i, *dimp);
  1074. #endif
  1075.     sprintf(tempStr, "%ld ", *dimp);
  1076.     writen(sock, tempStr, strlen(tempStr));
  1077.     nels *= *dimp;
  1078.     ++dimp;
  1079.     }
  1080. #ifdef DEBUG
  1081.     fprintf(stderr, ". done with dims\n");
  1082. #endif
  1083. }
  1084. #endif
  1085.  
  1086. #if 1
  1087. ObjPtr ReceiveExtraStuffObjectArray(obj, connection)
  1088. ObjPtr obj, connection;
  1089. {
  1090.     ReceiveExtraStuffObjectArraySpecial(obj, connection);
  1091. }
  1092. #else
  1093. ObjPtr ReceiveExtraStuffObjectArray(obj, connection)
  1094. ObjPtr obj, connection;
  1095. {
  1096.     int sock, rank, i;
  1097.     long *dimp, nels, oneDim;
  1098.     ObjPtr *elsPtr;
  1099.  
  1100.     sock = ((ConnectionPtr) connection) -> sock;
  1101.  
  1102.     rank = ReceiveRealAscii(connection);
  1103. #ifdef DEBUG
  1104.     fprintf(stderr, "got rank = %d\n", rank);
  1105. #endif
  1106.     RANK(obj) = rank;
  1107.  
  1108. #ifdef DEBUG
  1109.     fprintf(stderr, "getting dims -");
  1110. #endif
  1111.     dimp = Alloc(rank * sizeof(long));
  1112.     DIMS(obj) = dimp;
  1113.     nels = 1;
  1114.     for (i = 0; i < rank; ++i)
  1115.     {
  1116.     oneDim = ReceiveRealAscii(connection);
  1117.     nels *= oneDim;
  1118.     *dimp = oneDim;
  1119.     ++dimp;
  1120. #ifdef DEBUG
  1121.     fprintf(stderr, " d%d=%ld", i, oneDim);
  1122. #endif
  1123.     }
  1124. #ifdef DEBUG
  1125.     fprintf(stderr, ". done with dims\n");
  1126. #endif
  1127.  
  1128.     elsPtr = (void *) Alloc(nels * sizeof(ObjPtr));
  1129.     if (!elsPtr)
  1130.     {
  1131.     OMErr();
  1132.     return ObjFalse;
  1133.     }
  1134.  
  1135.     ELEMENTS(obj) = elsPtr;
  1136.     for (i = 0; i < nels; ++i)
  1137.     {
  1138.     elsPtr[i] = (ObjPtr) NETSTUBFLAG;
  1139.     }
  1140.     return ObjTrue;
  1141. }
  1142. #endif
  1143.  
  1144. ObjPtr TransmitExtraStuffString(obj, connection)
  1145. ObjPtr obj, connection;
  1146. {
  1147.     int sock;
  1148.  
  1149.     if (!obj)
  1150.     return ObjFalse;
  1151.  
  1152.     sock = ((ConnectionPtr) connection) -> sock;
  1153.  
  1154.     if (sock < 0)
  1155.     return ObjFalse;
  1156.  
  1157.     /* HAK! should figure out a way to avoid relying on the \0 */
  1158.     /* transmit everything, even the \0 on the end */
  1159. #ifdef DEBUG
  1160.     fprintf(stderr, "%s", ((SPtr) obj) -> stringPtr);
  1161. #endif
  1162.     writen(sock, ((SPtr) obj) -> stringPtr, 1 + strlen(((SPtr) obj) -> stringPtr));
  1163.     return ObjTrue;
  1164. }
  1165.  
  1166. ObjPtr ReceiveExtraStuffString(obj, connection)
  1167. ObjPtr obj, connection;
  1168. {
  1169.     double time;
  1170.     int sock;
  1171.     char inChar;
  1172.     int someDigits;
  1173.  
  1174.     /* HAK! figure out how to do this reentrantly */
  1175.     time = Clock();
  1176.     sock = ((ConnectionPtr) connection) -> sock;
  1177.     someDigits = false;
  1178.  
  1179.     if (obj)
  1180.     {
  1181.     char s[1000];
  1182.     int si;
  1183.  
  1184.     si = 0;
  1185.     s[si] = '\0';
  1186.  
  1187.     Free(((SPtr) obj) -> stringPtr);    /* really! */
  1188.     ((SPtr) obj) -> stringPtr = (char *) 0;
  1189.  
  1190.     while(Clock() < time + JOHNSTIMEOUT)
  1191.     {
  1192.         if (1 == read(sock, &inChar, 1))
  1193.         {
  1194.         if (inChar)
  1195.         {
  1196.             someDigits = true;
  1197.             s[si++] = inChar;
  1198.             s[si] = '\0';
  1199.         }
  1200.  
  1201.         if (!inChar || si >= 999)
  1202.         {
  1203.             if ( ! ((SPtr) obj) -> stringPtr)
  1204.             {
  1205.             ((SPtr) obj) -> stringPtr = Alloc(1 + strlen(s));
  1206.             if (! ((SPtr) obj) -> stringPtr)
  1207.             {
  1208.                 OMErr();
  1209.                 return ObjFalse;
  1210.             }
  1211.             strcpy(((SPtr) obj) -> stringPtr, s);
  1212.             }
  1213.             else
  1214.             {
  1215.             ((SPtr) obj) -> stringPtr = Realloc(((SPtr) obj) -> stringPtr, strlen(s));
  1216.             if (! ((SPtr) obj) -> stringPtr)
  1217.             {
  1218.                 OMErr();
  1219.                 return ObjFalse;
  1220.             }
  1221.             strcat(((SPtr) obj) -> stringPtr, s);
  1222.             }
  1223.             si = 0;
  1224.             s[si] = '\0';
  1225.         }
  1226.  
  1227.         if (!inChar)
  1228.         {
  1229.             return ObjTrue;
  1230.         }
  1231.         }
  1232.     }
  1233.     /* only got here if we timed out */
  1234. fprintf(stderr, "hack timeout in ReceiveExtraStuffString");
  1235.     return ObjFalse;
  1236.     }
  1237.     return ObjTrue;
  1238. }
  1239.  
  1240. ObjPtr TransmitExtraStuffObject(obj, connection)
  1241. ObjPtr obj, connection;
  1242. {
  1243.     int sock;
  1244.  
  1245.     if (!obj)
  1246.     return ObjFalse;
  1247.  
  1248.     sock = ((ConnectionPtr) connection) -> sock;
  1249.     if (sock < 0)
  1250.     return ObjFalse;
  1251.  
  1252.     if (IsInt(obj))
  1253.     {
  1254.     char buf[50];
  1255.  
  1256.     sprintf(buf, "%d ", ((IPtr) obj) -> intpart);
  1257. #ifdef DEBUG
  1258.     fprintf(stderr, "%s", buf);
  1259. #endif
  1260.     writen(sock, buf, strlen(buf));
  1261.     }
  1262.     else if (IsReal(obj))
  1263.     {
  1264.     char buf[100];
  1265.  
  1266.     sprintf(buf, "%g ", ((RPtr) obj) -> realpart);
  1267. #ifdef DEBUG
  1268.     fprintf(stderr, "%s", buf);
  1269. #endif
  1270.     writen(sock, buf, strlen(buf));
  1271.     }
  1272.     return ObjTrue;
  1273. }
  1274.  
  1275. ObjPtr ReceiveExtraStuffObject(obj, connection)
  1276. ObjPtr obj, connection;
  1277. {
  1278.     int sock;
  1279.     char inChar;
  1280.     int someDigits;
  1281.     long int ltmp;
  1282.     double time;
  1283.  
  1284.     if (!obj)
  1285.     return ObjFalse;
  1286.  
  1287.     /* HAK! figure out how to do this reentrantly */
  1288.     time = Clock();
  1289.  
  1290.     ltmp = 0;
  1291.     someDigits = false;
  1292.     inChar = 'x';
  1293.  
  1294.     sock = ((ConnectionPtr) connection) -> sock;
  1295.  
  1296.     if (IsInt(obj))
  1297.     {
  1298.     while (Clock() < time + JOHNSTIMEOUT)
  1299.     {
  1300.     if (1 == read(sock, &inChar, 1))
  1301.     {
  1302.         if (isspace(inChar) && (inChar != '\n') && !someDigits)
  1303.         {
  1304.         /* skipping blanks */
  1305.         }
  1306.         else if (inChar >= '0' && inChar <= '9')
  1307.         {
  1308.         someDigits = true;
  1309.         ltmp *= 10;
  1310.         ltmp += inChar - '0';
  1311.         }
  1312.         else if (inChar == '\0' || inChar == '\n')
  1313.         {
  1314.         ((ConnectionPtr) connection) -> gotCmdEnd = true;
  1315.         return ObjFalse;
  1316.         }
  1317.         else
  1318.         {
  1319.         ((IPtr) obj) -> intpart = ltmp;
  1320.         return ObjTrue;
  1321.         }
  1322.     }
  1323.     }    
  1324.     /* only got here if we timed out */
  1325. fprintf(stderr, "hack timeout in ReceiveExtraStuffObject");
  1326.     return ObjFalse;
  1327.     }
  1328.     else if (IsReal(obj))
  1329.     {
  1330.     ((RPtr) obj) -> realpart = ReceiveRealAscii(connection);
  1331.     }
  1332.  
  1333.     return ObjTrue;
  1334. }
  1335.  
  1336. #ifdef PROTO
  1337. ObjPtr TransmitExtraStuffPalette(ObjPtr obj, ObjPtr connection)
  1338. #else
  1339. ObjPtr TransmitExtraStuffPalette(obj, connection)
  1340. ObjPtr obj, connection;
  1341. #endif
  1342. {
  1343.     return ObjTrue;
  1344. }
  1345.  
  1346. #ifdef PROTO
  1347. ObjPtr ReceiveExtraStuffPalette(ObjPtr obj, ObjPtr connection)
  1348. #else
  1349. ObjPtr ReceiveExtraStuffPalette(obj, connection)
  1350. ObjPtr obj, connection;
  1351. #endif
  1352. {
  1353.     ObjPtr atomPal;
  1354.  
  1355. #if 0
  1356.     atomPal = NewAtomicPalette(); /* HAK */
  1357.     CopyPalette(obj, atomPal);
  1358. #endif
  1359.     return ObjTrue;
  1360. }
  1361.  
  1362. #endif /* ifdef SOCKETS */
  1363.  
  1364. int PublishObject(obj)
  1365. ObjPtr obj;
  1366. /* Marks an object as published. Returns the (new?) NetworkID of the object,
  1367.  * or 0 if it failed for some reason.
  1368.  */
  1369. {
  1370.     int netid;
  1371.  
  1372.     netid = 0;
  1373. #ifdef SOCKETS
  1374.     if (!GetVar(obj, NETWORKID))
  1375.     {
  1376.     SetVar(obj, NETWORKID, NewInt(GetNetworkID()));
  1377.     }
  1378.     netid = GetInt(GetIntVar("PublishObject", obj, NETWORKID));
  1379.  
  1380.     if (!IsPublished(obj))
  1381.     {
  1382.     obj -> flags = obj -> flags | ISPUBLISHED;
  1383.     if (!allPublished)
  1384.     {
  1385. fprintf(stderr, "Whoops! recreating allPublished!\n");
  1386.         allPublished = NewList();
  1387.         AddToReferenceList(allPublished);
  1388.     }
  1389.  
  1390.     PrefixList(allPublished, obj);
  1391.     }
  1392. #endif
  1393.     return netid;
  1394. }
  1395.  
  1396. #if 0
  1397. void UnPublishObject(obj)
  1398. ObjPtr obj;
  1399. /* Unmarks the published flag, removes object from published list */
  1400. {
  1401. #ifdef SOCKETS
  1402.     if (IsPublished(obj))
  1403.     {
  1404. #if 0
  1405.     obj -> flags = obj -> flags & ~ISPUBLISHED;
  1406. #endif
  1407.     DeleteFromList(allPublished, obj);
  1408.     DeleteFromList(allAdvertised, obj);
  1409. #ifdef SAVEDELETED
  1410.     if (!allDeletedPublished);
  1411.     {
  1412. fprintf(stderr, "Whoops! recreating allDeletedPublished!\n");
  1413.         allDeletedPublished = NewList();
  1414.         AddToReferenceList(allDeletedPublished);
  1415.     }
  1416.     PrefixList(allDeletedPublished, obj);
  1417. #endif
  1418.     }
  1419. #endif
  1420. }
  1421. #endif
  1422.  
  1423. ObjPtr FindPublishedObject(num)
  1424. unsigned long num;
  1425. {
  1426. #ifdef SOCKETS
  1427.     ObjPtr retVal;
  1428.     ThingListPtr runner;
  1429.  
  1430.     retVal = ObjFalse;
  1431.  
  1432.     if (allPublished)
  1433.     {
  1434.  
  1435.     runner = LISTOF(allPublished);
  1436.     while (runner && (num != GetInt(GetIntVar("FindPublishedObject", runner -> thing, NETWORKID))))
  1437.     {
  1438.         runner = runner -> next;
  1439.     }
  1440.     if (runner)
  1441.     {
  1442.         retVal = runner -> thing;
  1443.     }
  1444.     }
  1445.  
  1446.     /* if we didn't find it, try the list of Advertised objects */
  1447.     if (!retVal && allAdvertised)
  1448.     {
  1449.     runner = LISTOF(allAdvertised);
  1450.     while (runner && (num != GetInt(GetIntVar("FindPublishedObject", runner -> thing, NETWORKID))))
  1451.     {
  1452.         runner = runner -> next;
  1453.     }
  1454.     if (runner)
  1455.     {
  1456.         retVal = runner -> thing;
  1457.     }
  1458.     }
  1459.  
  1460. #ifdef SAVEDELETED
  1461.     /* still not found, try the deleted list */
  1462.     if (retVal && allDeletedPublished)
  1463.     {
  1464.     runner = LISTOF(allDeletedPublished);
  1465.     while(runner && (num != GetInt(GetIntVar("FindPublishedObject", runner -> thing, NETWORKID))))
  1466.     {
  1467.         runner = runner -> next;
  1468.     }
  1469.     if (runner)
  1470.     {
  1471.         retVal = runner -> thing;
  1472.     }
  1473.     }
  1474. #endif
  1475.  
  1476.     return retVal;
  1477. #else
  1478.     return ObjFalse;
  1479. #endif
  1480. }
  1481.  
  1482. void InitNetObjects()
  1483. {
  1484. #ifdef SOCKETS
  1485.     SetMethod(objClass, TRANSMITEXTRA, TransmitExtraStuffObject);
  1486.     SetMethod(objClass, RECEIVEEXTRA, ReceiveExtraStuffObject);
  1487.  
  1488.     SetMethod(stringClass, TRANSMITEXTRA, TransmitExtraStuffString);
  1489.     SetMethod(stringClass, RECEIVEEXTRA, ReceiveExtraStuffString);
  1490.  
  1491.     SetMethod(paletteClass, TRANSMITEXTRA, TransmitExtraStuffPalette);
  1492.     SetMethod(paletteClass, RECEIVEEXTRA, ReceiveExtraStuffPalette);
  1493.  
  1494.     SetMethod(objectArrayClass, TRANSMITEXTRA, TransmitExtraStuffObjectArraySpecial);
  1495.     SetMethod(objectArrayClass, RECEIVEEXTRA, ReceiveExtraStuffObjectArraySpecial);
  1496.  
  1497.     allPublished = NewList();
  1498.     AddToReferenceList (allPublished);
  1499. #ifdef SAVEDELETED
  1500.     allDeletedPublished = NewList();
  1501.     AddToReferenceList (allDeletedPublished);
  1502. #endif
  1503.  
  1504. #endif
  1505. }
  1506.  
  1507. void KillNetObjects()
  1508. {
  1509. #ifdef SOCKETS
  1510.     RemoveFromReferenceList(allPublished);
  1511. #endif
  1512. }
  1513.